package org.example.scoresystem_backen.controller;

import org.example.scoresystem_backen.common.Result;
import org.example.scoresystem_backen.entity.Score;
import org.example.scoresystem_backen.service.ScoreService;
import org.example.scoresystem_backen.dto.PageRequest;
import org.example.scoresystem_backen.dto.PageResponse;
import org.example.scoresystem_backen.dto.ScoreDetailDTO;
import org.example.scoresystem_backen.dto.StudentOptionDTO;
import org.example.scoresystem_backen.dto.CourseOptionDTO;
import org.example.scoresystem_backen.util.AuthUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.List;

/**
 * 成绩控制器
 * 实现分页查询、CRUD操作，符合RESTful规范
 */
@RestController
@RequestMapping("/api/scores")
@CrossOrigin(origins = "*")
public class ScoreController {

    @Autowired
    private ScoreService scoreService;
    
    // ========== 分页查询接口 ==========

    /**
     * 分页查询成绩详情（支持搜索和过滤）
     * @param page 页码（默认1）
     * @param pageSize 每页条数（默认10，最大100）
     * @param search 搜索关键词（按学号或姓名模糊查询）
     * @param classId 班级ID过滤
     * @param courseId 课程ID过滤
     * @return 分页响应结果
     */
    @GetMapping
    public Result<PageResponse<ScoreDetailDTO>> getScores(
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "10") Integer pageSize,
            @RequestParam(required = false) String search,
            @RequestParam(required = false) Integer classId,
            @RequestParam(required = false) Integer courseId) {
        try {
            // 构建分页请求
            PageRequest pageRequest = new PageRequest();
            pageRequest.setPage(page);
            pageRequest.setPageSize(pageSize);
            pageRequest.setSearch(search);
            pageRequest.setClassId(classId);
            pageRequest.setCourseId(courseId);

            // 权限控制
            Integer currentUserId = AuthUtil.getCurrentUserId();
            String userType = AuthUtil.getCurrentUserType();

            if (currentUserId == null) {
                return Result.error("用户未登录");
            }

            PageResponse<ScoreDetailDTO> response;

            if ("student".equals(userType)) {
                // 学生只能查看自己的成绩
                response = scoreService.findScoreDetailsByStudentIdWithPagination(currentUserId, pageRequest);
            } else if ("admin".equals(userType) || "super_admin".equals(userType)) {
                // 管理员和超级管理员可以查看所有成绩
                response = scoreService.findScoreDetailsWithPagination(pageRequest);
            } else {
                return Result.error("用户权限不足");
            }

            return Result.success("查询成功", response);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }

    // ========== CRUD操作接口 ==========

    /**
     * 创建成绩记录
     * @param score 成绩信息
     * @return 创建结果
     */
    @PostMapping
    public Result<Score> createScore(@RequestBody Score score) {
        try {
            // 权限检查：只有管理员可以创建成绩
            if (!AuthUtil.isAdmin()) {
                return Result.error("权限不足，只有管理员可以创建成绩");
            }

            Score createdScore = scoreService.createScoreWithValidation(score);
            return Result.success("成绩录入成功", createdScore);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }

    /**
     * 更新成绩记录
     * @param id 成绩ID
     * @param score 成绩信息
     * @return 更新结果
     */
    @PutMapping("/{id}")
    public Result<Score> updateScore(@PathVariable Integer id, @RequestBody Score score) {
        try {
            // 权限检查：只有管理员可以更新成绩
            if (!AuthUtil.isAdmin()) {
                return Result.error("权限不足，只有管理员可以更新成绩");
            }

            // 设置ID
            score.setId(id);
            Score updatedScore = scoreService.updateScoreWithValidation(score);
            return Result.success("成绩更新成功", updatedScore);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }

    /**
     * 删除成绩记录
     * @param id 成绩ID
     * @return 删除结果
     */
    @DeleteMapping("/{id}")
    public Result<Void> deleteScore(@PathVariable Integer id) {
        try {
            // 权限检查：只有管理员可以删除成绩
            if (!AuthUtil.isAdmin()) {
                return Result.error("权限不足，只有管理员可以删除成绩");
            }

            scoreService.deleteScoreWithValidation(id);
            return Result.success("成绩删除成功");
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    
    // ========== 辅助数据接口 ==========

    /**
     * 获取学生选项列表（用于下拉选择）
     * @return 学生选项列表
     */
    @GetMapping("/students/options")
    public Result<List<StudentOptionDTO>> getStudentOptions() {
        try {
            // 权限检查：只有管理员可以获取学生选项
            if (!AuthUtil.isAdmin()) {
                return Result.error("权限不足，只有管理员可以获取学生选项");
            }

            List<StudentOptionDTO> options = scoreService.getStudentOptions();
            return Result.success("获取学生选项成功", options);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }

    /**
     * 获取课程选项列表（用于下拉选择）
     * @return 课程选项列表
     */
    @GetMapping("/courses/options")
    public Result<List<CourseOptionDTO>> getCourseOptions() {
        try {
            List<CourseOptionDTO> options = scoreService.getCourseOptions();
            return Result.success("获取课程选项成功", options);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }

    // ========== 统计分析接口 ==========

    /**
     * 计算学生平均分
     * @param studentId 学生ID
     * @return 平均分
     */
    @GetMapping("/average/student/{studentId}")
    public Result<BigDecimal> calculateAverageScoreByStudentId(@PathVariable Integer studentId) {
        try {
            // 权限检查：学生只能查看自己的平均分，管理员可以查看所有
            Integer currentUserId = AuthUtil.getCurrentUserId();
            String userType = AuthUtil.getCurrentUserType();

            if ("student".equals(userType) && !currentUserId.equals(studentId)) {
                return Result.error("权限不足，学生只能查看自己的成绩");
            }

            BigDecimal average = scoreService.calculateAverageScoreByStudentId(studentId);
            return Result.success("计算成功", average);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }

    /**
     * 计算课程平均分
     * @param courseId 课程ID
     * @return 平均分
     */
    @GetMapping("/average/course/{courseId}")
    public Result<BigDecimal> calculateAverageScoreByCourseId(@PathVariable Integer courseId) {
        try {
            BigDecimal average = scoreService.calculateAverageScoreByCourseId(courseId);
            return Result.success("计算成功", average);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }

    /**
     * 计算班级平均分
     * @param classId 班级ID
     * @return 平均分
     */
    @GetMapping("/average/class/{classId}")
    public Result<BigDecimal> calculateAverageScoreByClassId(@PathVariable Integer classId) {
        try {
            BigDecimal average = scoreService.calculateAverageScoreByClassId(classId);
            return Result.success("计算成功", average);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
    


    // ========== 批量操作接口 ==========

    /**
     * 批量导入成绩
     * @param scores 成绩列表
     * @return 导入结果
     */
    @PostMapping("/batch")
    public Result<List<Score>> batchImportScores(@RequestBody List<Score> scores) {
        try {
            // 权限检查：只有管理员可以批量导入成绩
            if (!AuthUtil.isAdmin()) {
                return Result.error("权限不足，只有管理员可以批量导入成绩");
            }

            List<Score> importedScores = scoreService.batchImportScores(scores);
            return Result.success("批量导入成功", importedScores);
        } catch (Exception e) {
            return Result.error(e.getMessage());
        }
    }
}
